shared source/wpf/src/host/dll/oledocumentview.cxx

   1 //+-----------------------------------------------------------------------
   2 //
   3 //  Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 //  Description:
   6 //     Implements the OleDocumentView class of PresentationHost.
   7 //
   8 //  History:
   9 //     2002/06/27-murrayw
  10 //          Created
  11 //     2007/09/20-[....]
  12 //          Ported Windows->DevDiv. See SourcesHistory.txt.
  13 //
  14 //------------------------------------------------------------------------
  15
  16 #include "Precompiled.hxx"
  17 #include "OleDocumentView.hxx"
  18 #include "OleDocument.hxx"
  19 #include "OleInPlaceActiveObject.hxx"
  20 #include "ErrorPage.hxx"
  21 #include "Utilities.hxx"
  22
  23
  24 extern HINSTANCE  g_hInstance;
  25
  26
  27 //******************************************************************************
  28 //
  29 // COleDocumentView::COleDocumentView()
  30 //
  31 //******************************************************************************
  32
  33 COleDocumentView::COleDocumentView(__in COleDocument *pOleDoc):
  34     m_pInPlaceSite(0), m_pInPlaceFrame(0), m_pInPlaceUIWindow(0), m_FrameInfo(),
  35     m_fShow(false), m_fUIActive(false), m_fInPlaceActive(false), m_Rect(),
  36     m_MenuGroupWidth(),
  37     m_hDocObjMenu(0), m_hSharedMenu(0), m_hViewMenu(0), m_hOleMenu(0)
  38 {
  39     //This is interface aggregation, don't AddRef the OleDoc
  40     m_pOleDoc          = pOleDoc;
  41 }
  42
  43 //******************************************************************************
  44 //
  45 // COleDocumentView::~COleDocumentView()
  46 //
  47 //******************************************************************************
  48
  49 COleDocumentView::~COleDocumentView()
  50 {
  51     //Should already have been destroyed when we remove menus. Calling it here
  52     //to be on the safe side
  53     DestroyMenuResources();
  54
  55     ReleaseInterface(m_pInPlaceSite);
  56     ReleaseInterface(m_pInPlaceFrame);
  57     ReleaseInterface(m_pInPlaceUIWindow);
  58 }
  59
  60 //******************************************************************************
  61 //
  62 // IUnknown Implementation
  63 //
  64 //******************************************************************************
  65
  66 //******************************************************************************
  67 //
  68 // COleDocumentView::QueryInterface
  69 //
  70 //******************************************************************************
  71
  72 STDMETHODIMP COleDocumentView::QueryInterface(REFIID riid,
  73                                               __out LPVOID *ppReturn)
  74 {
  75     return m_pOleDoc->QueryInterface(riid, ppReturn);
  76 }
  77
  78 //******************************************************************************
  79 //
  80 // COleDocumentView::AddRef
  81 //
  82 //******************************************************************************
  83
  84 STDMETHODIMP_(DWORD) COleDocumentView::AddRef()
  85 {
  86     return m_pOleDoc->AddRef();
  87 }
  88
  89 //******************************************************************************
  90 //
  91 // COleDocumentView::Release
  92 //
  93 //******************************************************************************
  94
  95 STDMETHODIMP_(DWORD) COleDocumentView::Release()
  96 {
  97     return m_pOleDoc->Release();
  98 }
  99
 100 //******************************************************************************
 101 //
 102 // COleDocumentView::SetInPlaceSite()
 103 //
 104 //******************************************************************************
 105
 106 STDMETHODIMP COleDocumentView::SetInPlaceSite(__in_opt IOleInPlaceSite *pNewSite)
 107 {
 108     HRESULT hr = S_OK;
 109
 110     if (m_pInPlaceSite)
 111     {
 112         if (m_fUIActive)
 113         {
 114             CKHR(DeactivateUI());
 115         }
 116
 117         if (m_fInPlaceActive)
 118         {
 119             CKHR(DeactivateInPlace());
 120         }
 121
 122         if (m_pInPlaceFrame)
 123         {
 124             ReleaseInterface(m_pInPlaceFrame);
 125         }
 126
 127         if (m_pInPlaceUIWindow)
 128         {
 129             ReleaseInterface(m_pInPlaceUIWindow);
 130         }
 131
 132         ReleaseInterface(m_pInPlaceSite);
 133     }
 134
 135     m_pInPlaceSite = pNewSite;
 136
 137     if (m_pInPlaceSite)
 138     {
 139         m_pInPlaceSite->AddRef();
 140
 141         RECT  rcClip;
 142
 143         m_FrameInfo.cb = sizeof(m_FrameInfo);
 144
 145         CKHR(m_pInPlaceSite->GetWindowContext(&m_pInPlaceFrame,
 146                                          &m_pInPlaceUIWindow,
 147                                          &m_Rect,
 148                                          &rcClip,
 149                                          &m_FrameInfo));
 150     }
 151
 152 Cleanup:
 153
 154     return hr;
 155 }
 156
 157 //******************************************************************************
 158 //
 159 // COleDocumentView::GetInPlaceSite()
 160 //
 161 //******************************************************************************
 162
 163 STDMETHODIMP COleDocumentView::GetInPlaceSite(__out IOleInPlaceSite **ppInPlaceSite)
 164 {
 165     HRESULT  hr = E_FAIL;
 166
 167     CK_PARG(ppInPlaceSite)
 168     *ppInPlaceSite = m_pInPlaceSite;
 169
 170     if (*ppInPlaceSite)
 171     {
 172         (*ppInPlaceSite)->AddRef();
 173         hr = S_OK;
 174     }
 175
 176 Cleanup:
 177     return hr;
 178 }
 179
 180 //******************************************************************************
 181 //
 182 // COleDocumentView::GetDocument()
 183 //
 184 //******************************************************************************
 185
 186 STDMETHODIMP COleDocumentView::GetDocument(__out IUnknown **ppUnk)
 187 {
 188     HRESULT hr = S_OK;
 189     CK_PARG(ppUnk);
 190     *ppUnk = NULL;
 191
 192     CKHR(m_pOleDoc->QueryInterface(IID_IUnknown, (void **)ppUnk));
 193 Cleanup:
 194     return hr;
 195 }
 196
 197 //******************************************************************************
 198 //
 199 // COleDocumentView::SetRect()
 200 //
 201 //******************************************************************************
 202
 203 void COleDocumentView::MoveViewportHelper(int x, int y, int nWidth, int nHeight)
 204 {
 205     // update the dimensions of the top dockobj hwnd using the dimensions provided
 206
 207     // A 0x0 rect is passed to IOleDocumentView::SetRect() or IOleInPlaceObject::SetObjectRects()
 208     // (depending on the hosting mode) when the top-level window is minimized. This appears to be a bug
 209     // in the ATL host, which gets 0x0 in its WM_SIZE handler but ignores the SIZE_MINIMIZED flag.
 210     // IE probably does something similar. But normally child windows are not resized or moved when the
 211     // top-level window is minimized.
 212     if(nWidth > 0 || nHeight > 0)
 213     {
 214         // Drawing optimization (last param of MoveWindow): don't paint the background of the top window if the
 215         // RBW is present. (In spite of the WS_CLIPCHILDREN style, this drawing does take place, at least
 216         // during resizing.)
 217         MoveWindow(m_pOleDoc->m_hwndTop, x, y, nWidth, nHeight, !m_pOleDoc->ApplicationHelper());
 218         if(m_pOleDoc->ApplicationHelper())
 219         {
 220             // update dimensions of the RBW window.  Note, x,y of RBW should always be
 221             // 0,0 relative to the top dockobj hwnd
 222             (m_pOleDoc->ApplicationHelper())->Move(0, 0, nWidth, nHeight);
 223         }
 224
 225         CErrorPage::SetRect(x, y, nWidth, nHeight);
 226     }
 227 }
 228
 229 STDMETHODIMP COleDocumentView::SetRect(__in LPRECT pRect)
 230 {
 231     HRESULT hr = S_OK;
 232
 233     CK_PARG(pRect);
 234
 235     m_Rect = *pRect;
 236
 237     // MoveViewportHelper expects x, y, width, height
 238     MoveViewportHelper(m_Rect.left,
 239                        m_Rect.top,
 240                        m_Rect.right - m_Rect.left,
 241                        m_Rect.bottom - m_Rect.top);
 242
 243
 244 Cleanup:
 245
 246     return hr;
 247 }
 248
 249 //******************************************************************************
 250 //
 251 // COleDocumentView::GetRect()
 252 //
 253 //******************************************************************************
 254
 255 STDMETHODIMP COleDocumentView::GetRect(__out LPRECT pRect)
 256 {
 257     HRESULT hr = S_OK;
 258
 259     CK_PARG(pRect);
 260
 261     (*pRect) = m_Rect;
 262
 263 Cleanup:
 264
 265     return hr;
 266 }
 267
 268 //******************************************************************************
 269 //
 270 // COleDocumentView::SetRectComplex()
 271 //
 272 //******************************************************************************
 273
 274 STDMETHODIMP COleDocumentView::SetRectComplex(LPRECT /* prcView */,
 275                                               LPRECT /* prcHScroll */,
 276                                               LPRECT /* prcVScroll */,
 277                                               LPRECT /* prcSizeBox */)
 278 {
 279     return E_NOTIMPL;
 280 }
 281
 282 //******************************************************************************
 283 //
 284 // COleDocumentView::Show()
 285 //
 286 //******************************************************************************
 287 void COleDocumentView::ShowHelper(bool fShow)
 288 {
 289     ShowWindow(m_pOleDoc->m_hwndTop,fShow);
 290     if(m_pOleDoc->ApplicationHelper())
 291     {
 292         (m_pOleDoc->ApplicationHelper())->Show(fShow);
 293     }
 294     else
 295     {
 296         //ASSERT(CErrorPage::IsActive());
 297         //SP2: Not true anymore. UI Activation now happens before loading any managed code.
 298     }
 299
 300     //
 301 }
 302
 303 STDMETHODIMP COleDocumentView::Show(BOOL bShow)
 304 {
 305     m_fShow = bShow;
 306
 307     if (bShow)
 308     {
 309         //if the object is not in-place active, make it that way
 310         if (!m_fInPlaceActive)
 311         {
 312             ActivateInPlace();
 313         }
 314
 315         ShowHelper(true);
 316     }
 317     else
 318     {
 319         //if the object is UI active, make remove that state
 320         if (m_fUIActive)
 321         {
 322             DeactivateUI();
 323         }
 324
 325         //hide the window
 326         ShowHelper(false);
 327     }
 328
 329     return S_OK;
 330 }
 331
 332 //******************************************************************************
 333 //
 334 // COleDocumentView::UIActivate()
 335 //
 336 //******************************************************************************
 337
 338 STDMETHODIMP COleDocumentView::UIActivate(BOOL bActivate)
 339 {
 340     if (bActivate)
 341     {
 342         return ActivateUI();
 343     }
 344
 345     return DeactivateUI();
 346 }
 347
 348 //******************************************************************************
 349 //
 350 // COleDocumentView::ActivateUI()
 351 //
 352 //******************************************************************************
 353
 354 STDMETHODIMP COleDocumentView::ActivateUI()
 355 {
 356     HRESULT hr = S_OK;
 357
 358     //set the active object either one of these could be good
 359     if (m_pInPlaceFrame)
 360     {
 361         m_pInPlaceFrame->SetActiveObject(m_pOleDoc->m_pOleInPlaceActiveObject,
 362                                          NULL);
 363     }
 364
 365     if (m_pInPlaceUIWindow)
 366     {
 367         m_pInPlaceUIWindow->SetActiveObject(m_pOleDoc->m_pOleInPlaceActiveObject,
 368                                             NULL);
 369     }
 370
 371     if (m_pInPlaceSite)
 372     {
 373         m_fUIActive = TRUE;
 374
 375         ActivateInPlace();
 376
 377         m_pInPlaceSite->OnUIActivate();
 378
 379         CKHR(InsertMergedMenus());
 380
 381         SetFocus(m_pOleDoc->m_hwndTop);
 382     }
 383
 384 Cleanup:
 385
 386     return hr;
 387 }
 388
 389 //******************************************************************************
 390 //
 391 // COleDocumentView::DeactivateUI()
 392 //
 393 //******************************************************************************
 394
 395 STDMETHODIMP COleDocumentView::DeactivateUI()
 396 {
 397     m_fUIActive = FALSE;
 398
 399     RemoveMergedMenus();
 400
 401     //remove the active object either one of these could be good
 402     if (m_pInPlaceFrame)
 403     {
 404         m_pInPlaceFrame->SetActiveObject(NULL, NULL);
 405     }
 406
 407     if (m_pInPlaceUIWindow)
 408     {
 409         m_pInPlaceUIWindow->SetActiveObject(NULL, NULL);
 410     }
 411
 412     if (m_pInPlaceSite)
 413     {
 414         m_pInPlaceSite->OnUIDeactivate(FALSE);
 415     }
 416
 417     return S_OK;
 418 }
 419
 420 //******************************************************************************
 421 //
 422 // COleDocumentView::Open()
 423 //
 424 //******************************************************************************
 425
 426 STDMETHODIMP COleDocumentView::Open(void)
 427 {
 428     return S_OK;
 429 }
 430
 431 //******************************************************************************
 432 //
 433 // COleDocumentView::CloseView()
 434 //
 435 //******************************************************************************
 436
 437 STDMETHODIMP COleDocumentView::CloseView(DWORD /* dwReserved */)
 438 {
 439     SetInPlaceSite(NULL);
 440     return S_OK;
 441 }
 442
 443 //******************************************************************************
 444 //
 445 // COleDocumentView::SaveViewState()
 446 //
 447 //******************************************************************************
 448
 449 STDMETHODIMP COleDocumentView::SaveViewState(IStream * /* pStream */)
 450 {
 451     return E_NOTIMPL;
 452 }
 453
 454 //******************************************************************************
 455 //
 456 // COleDocumentView::ApplyViewState()
 457 //
 458 //******************************************************************************
 459
 460 STDMETHODIMP COleDocumentView::ApplyViewState(IStream * /* pStream */)
 461 {
 462     return E_NOTIMPL;
 463 }
 464
 465 //******************************************************************************
 466 //
 467 // COleDocumentView::Clone()
 468 //
 469 //******************************************************************************
 470
 471 STDMETHODIMP COleDocumentView::Clone(IOleInPlaceSite * /* pIPSite */,
 472                                      IOleDocumentView ** /* ppView */)
 473 {
 474     return E_NOTIMPL;
 475 }
 476
 477 //******************************************************************************
 478 //
 479 // COleDocumentView::ActivateInPlace()
 480 //
 481 //******************************************************************************
 482 void COleDocumentView::SetParentHelper(HWND hwndParent)
 483 {
 484     // if hwndParent == NULL We are going away
 485     if (hwndParent == NULL)
 486     {
 487         SetWindowLong(m_pOleDoc->m_hwndTop, GWL_STYLE, WS_OVERLAPPED | WS_CLIPSIBLINGS | WS_DISABLED);
 488     }
 489     else
 490     {
 491         SetWindowLong(m_pOleDoc->m_hwndTop, GWL_STYLE, WS_CHILD | WS_VISIBLE | WS_CLIPCHILDREN);
 492     }
 493
 494     //This will notify the managed window to set up the parent or cleanup during shutdown
 495     //If we don't detach the parent window during shutdown, we will end up processing WM_DESTROY
 496     //twice since we close windows when Application is shutdown which posts one msg and when the
 497     //browser window is closed, the managed child window will get another one.
 498     //Detach the parent window to avoid that.
 499     SetParent(m_pOleDoc->m_hwndTop, hwndParent);
 500     SetWindowPos(m_pOleDoc->m_hwndTop, 0,0,0,0,0, SWP_FRAMECHANGED|SWP_NOMOVE|SWP_NOSIZE|SWP_NOZORDER);
 501
 502     //
 503 }
 504
 505 STDMETHODIMP COleDocumentView::ActivateInPlace()
 506 {
 507     HWND hwndParent;
 508
 509     m_fInPlaceActive = TRUE;
 510
 511     if (m_pInPlaceSite)
 512     {
 513         // tell the site we are in-place activating
 514         m_pInPlaceSite->OnInPlaceActivate();
 515
 516         m_pInPlaceSite->GetWindow(&hwndParent);
 517
 518         SetParentHelper(hwndParent);
 519     }
 520
 521     return S_OK;
 522 }
 523
 524 //******************************************************************************
 525 //
 526 // COleDocumentView::DeactivateInPlace()
 527 //
 528 //******************************************************************************
 529
 530 STDMETHODIMP COleDocumentView::DeactivateInPlace()
 531 {
 532     m_fInPlaceActive = FALSE;
 533
 534     if (m_pInPlaceSite)
 535     {
 536         // tell the site we are in-place deactivating
 537         m_pInPlaceSite->OnInPlaceDeactivate();
 538     }
 539
 540     //set the parent to NULL
 541     SetParentHelper(NULL);
 542
 543     return S_OK;
 544 }
 545
 546
 547 //******************************************************************************
 548 //
 549 // COleDocumentView::InsertMergedMenus()
 550 //
 551 //******************************************************************************
 552
 553 #define MSGFLT_ADD 1
 554 #define MSGFLT_REMOVE 2
 555 typedef BOOL (WINAPI *PFChangeWindowMessageFilter)(__in UINT message, __in DWORD dwFlag);
 556 typedef BOOL (WINAPI *PFChangeWindowMessageFilterEx)(HWND hwnd, UINT message, DWORD action, __inout_opt void* /*PCHANGEFILTERSTRUCT*/ pChangeFilterStruct);
 557
 558 BOOL WINAPI CallOldChangeWindowMessageFilter(HWND hwnd, UINT message, DWORD action, __inout_opt void* /*PCHANGEFILTERSTRUCT*/ pChangeFilterStruct)
 559 {
 560     static PFChangeWindowMessageFilter pfCWMF;
 561     if(!pfCWMF)
 562     {
 563         GetProcAddress(L"User32.dll", "ChangeWindowMessageFilter", &pfCWMF);
 564     }
 565     return (*pfCWMF)(message, action);
 566 }
 567
 568 HRESULT COleDocumentView::InsertMergedMenus()
 569 {
 570     EventWriteWpfHostUm_MergingMenusStart();
 571
 572     HRESULT hr = S_OK;
 573
 574     HWND    hwnd = NULL;
 575
 576     IProtectedModeMenuServices *pFrameMenuServices = NULL;
 577     WCHAR*  szText  = NULL;
 578     HMENU   hMenuToAdd   = NULL;
 579     int menuItemCount = 0;
 580
 581     CHECK_POINTER(m_pInPlaceFrame);
 582
 583     // IE7's interface for creating and loading menus in Protected Mode (ONLY)
 584     m_pInPlaceFrame->QueryInterface(IID_IProtectedModeMenuServices, (void**)&pFrameMenuServices);
 585
 586     //Create an empty menu
 587     Assert(m_hSharedMenu == NULL);
 588     if(!pFrameMenuServices)
 589     {
 590         m_hSharedMenu = CreateMenu();
 591         CK_ALLOC(m_hSharedMenu);
 592     }
 593     else
 594     {
 595         CKHR(pFrameMenuServices->CreateMenu(&m_hSharedMenu));
 596
 597         // Let the Low Integrity IE process send us WM_MENUSELECT & WM_COMMAND.
 598         // We prefer ChangeWindowMessageFilterEx(), which is new to Windows 7.
 599         PFChangeWindowMessageFilterEx pfCWMF = 0;
 600         GetProcAddress(L"User32.dll", "ChangeWindowMessageFilterEx", &pfCWMF);
 601         if(!pfCWMF)
 602         {
 603             pfCWMF = CallOldChangeWindowMessageFilter;
 604         }
 605         HWND hwnd = m_pOleDoc->m_hwndTop;
 606         BOOL res = (*pfCWMF)(hwnd, WM_MENUSELECT, MSGFLT_ADD, 0);
 607         ASSERT(res); (void)res;
 608         (*pfCWMF)(hwnd, WM_INITMENUPOPUP, MSGFLT_ADD, 0);
 609         (*pfCWMF)(hwnd, WM_COMMAND, MSGFLT_ADD, 0);
 610     }
 611
 612     //Zero out the merged menu array per OLE spec
 613     ZeroMemory(&m_MenuGroupWidth, sizeof(m_MenuGroupWidth));
 614
 615     //Call container to insert its menus
 616     CKHR(m_pInPlaceFrame->InsertMenus(m_hSharedMenu, &m_MenuGroupWidth));
 617
 618     // Remove the "Go To" menu
 619     // The items under "home" on this menu are added later by the browser frame.  If we
 620     // remove this item from the menu they will not be added because the browser cannot
 621     // find the menu.
 622     // CKHR(RemoveMenu(m_hSharedMenu, 33104, MF_BYCOMMAND));
 623
 624     // Load DocObj menus
 625     if(!pFrameMenuServices)
 626     {
 627         CKHR(LoadMenuFromMuiResource(&m_hDocObjMenu));
 628     }
 629     else
 630     {
 631         wchar_t dllPath[MAX_PATH];
 632         CHECK_NULL_FROM_WIN32(GetModuleFileName(g_hInstance, dllPath, MAX_PATH));
 633         CKHR(pFrameMenuServices->LoadMenuID(
 634                 dllPath, GetMenuResourceId(m_pOleDoc->GetCurrentMime()), &m_hDocObjMenu));
 635     }
 636
 637     CHECK_ZERO_FROM_WIN32(menuItemCount = GetMenuItemCount(m_hDocObjMenu));
 638     szText = new WCHAR[MAX_PATH+1];
 639     CK_ALLOC(szText);
 640
 641     // Add each menu in our resources to the shared menu.  Adding them in reverse order ensures that they
 642     // appear in a logical order when displayed
 643     for (int menuItemIndex = (menuItemCount-1); menuItemIndex > -1; menuItemIndex--)
 644     {
 645         // get the menu from the loaded set of menus
 646         hMenuToAdd = GetSubMenu(m_hDocObjMenu, menuItemIndex);
 647         CHECK_POINTER(hMenuToAdd);
 648
 649         // If this is our 'View' menu
 650         if (menuItemIndex == 1)
 651         {
 652             // keep track of the view menu so we can check/uncheck the "Status Bar" and "Full Screen" items.
 653             m_hViewMenu = hMenuToAdd;
 654
 655             // Determine the check state of the Status Bar and Full Screen menu options
 656             SetViewMenuItemsCheckState(hMenuToAdd);
 657         }
 658
 659         // Add the menu to the shared menus using the name it was given in the resource
 660         CHECK_ZERO_FROM_WIN32(GetMenuString(m_hDocObjMenu, menuItemIndex, szText, MAX_PATH+1, MF_BYPOSITION));
 661         CHECK_BOOL_FROM_WIN32(InsertMenu(m_hSharedMenu,
 662                                     m_MenuGroupWidth.width[0],
 663                                     MF_BYPOSITION | MF_POPUP,
 664                                     (UINT_PTR) hMenuToAdd,
 665                                     szText));
 666
 667         // update the OLEMENUGROUPWIDTHS
 668         m_MenuGroupWidth.width[1] += 1;
 669     }
 670
 671     //  Get the Ole menu descriptor
 672     CHECK_NULL_FROM_WIN32(m_hOleMenu = OleCreateMenuDescriptor(m_hSharedMenu, &m_MenuGroupWidth));
 673
 674     //
 675     // Set the Menu on the container's frame
 676     //
 677     // The window passed here should be the one from our IOleInPlaceActiveObject->GetWindow
 678     // As long as we are a single-instance server, this is okay.
 679     // If not, we need to create a window per View/InplaceActiveObj to handle messages from this menu
 680     CKHR(m_pOleDoc->GetWindow(&hwnd));
 681     CKHR(m_pInPlaceFrame->SetMenu(m_hSharedMenu, m_hOleMenu, hwnd));
 682
 683     /* //Testing - Adding a menu item to container owned menu group
 684     // Can Add successfully, but we don't get QueryStatus and Exec calls for it
 685     {
 686         hSubMenu = GetSubMenu(m_hSharedMenu,0);
 687         int nItems = GetMenuItemCount(hSubMenu);
 688
 689         MENUITEMINFOW mii = { sizeof(mii) };
 690
 691         mii.fMask = MIIM_ID | MIIM_TYPE;
 692         mii.wID = IDM_MENU_LAST+100;
 693         mii.fType = MFT_RADIOCHECK | MFT_STRING;
 694         mii.dwTypeData = L"Test";
 695         mii.cch = lstrlenW(L"Test");
 696
 697         BOOL result;
 698         result = InsertMenuItemW(hSubMenu, nItems, TRUE, &mii);
 699     } */
 700
 701     /* // TESTING Disable a menu item on a container owned menu
 702     //Can enable/disable container owned menus using Windows APIs incase we don't get QueryStatus
 703     //but we cannot handle the WM_COMMAND for these menu items
 704     {
 705     hSubMenu = GetSubMenu(m_hSharedMenu,0);
 706
 707     EnableMenuItem(hSubMenu, 0, MF_BYPOSITION | MF_GRAYED);
 708
 709     m_pInPlaceFrame->SetMenu(m_hSharedMenu, m_hOleMenu, m_pOleDoc->m_hwndTop);
 710     } */
 711
 712     EventWriteWpfHostUm_MergingMenusEnd();
 713
 714 Cleanup:
 715
 716     ReleaseInterface(pFrameMenuServices);
 717     if (FAILED(hr))
 718     {
 719         DestroyMenuResources();
 720     }
 721     delete [] szText;
 722
 723     return hr;
 724 }
 725
 726 //******************************************************************************
 727 //
 728 // COleDocumentView::LoadMenuFromMuiResource()
 729 //
 730 //******************************************************************************
 731 STDMETHODIMP
 732 COleDocumentView::LoadMenuFromMuiResource(__out_ecount(1) HMENU * menu)
 733 {
 734     HRESULT hr = S_OK;
 735     HINSTANCE hResourceInstance = LoadResourceDLL();
 736     CHECK_POINTER(hResourceInstance);
 737
 738     //Load the docobj menus for our mime type. hr is set to S_OK or HRESULT_FROM_WIN32(GetLastError())
 739     Assert(m_hDocObjMenu == NULL);
 740     *menu = LoadMenu(hResourceInstance, MAKEINTRESOURCE(GetMenuResourceId(m_pOleDoc->GetCurrentMime())));
 741     CHECK_POINTER(*menu);
 742
 743 Cleanup:
 744     FreeMUILibrary(hResourceInstance);
 745     return hr;
 746 }
 747
 748 //******************************************************************************
 749 //
 750 // COleDocumentView::SetViewMenuItemsCheckState()
 751 //
 752 //******************************************************************************
 753 STDMETHODIMP
 754 COleDocumentView::SetViewMenuItemsCheckState(HMENU viewMenu)
 755 {
 756     HRESULT hr = S_OK;
 757     IWebBrowser2        * pWebBrowserTop    = NULL;
 758     VARIANT_BOOL varBool;
 759     UINT uCheck;
 760
 761     CKHR(GetTopLevelBrowser(m_pOleDoc->GetClientSite(), &pWebBrowserTop));
 762
 763     // check Status Bar
 764     CKHR(pWebBrowserTop->get_StatusBar(&varBool));
 765     uCheck = (varBool == VARIANT_TRUE ? MF_CHECKED : MF_UNCHECKED);
 766     CheckMenuItem(viewMenu, IDM_VIEW_STATUSBAR, MF_BYCOMMAND | uCheck);
 767
 768     // check View Full Screen
 769     CKHR(pWebBrowserTop->get_TheaterMode(&varBool));
 770     uCheck = (varBool == VARIANT_TRUE ? MF_CHECKED : MF_UNCHECKED);
 771     CheckMenuItem(viewMenu, IDM_VIEW_FULLSCREEN, MF_BYCOMMAND | uCheck);
 772
 773 Cleanup:
 774     ReleaseInterface(pWebBrowserTop);
 775     return hr;
 776 }
 777
 778 //******************************************************************************
 779 //
 780 // COleDocumentView::RemoveMergedMenus()
 781 //
 782 //******************************************************************************
 783 void COleDocumentView::RemoveMergedMenus()
 784 {
 785     int menuItemCount = 0;
 786
 787     if (m_hSharedMenu == NULL)
 788     {
 789         Assert(m_hDocObjMenu == NULL);
 790         Assert(m_hOleMenu == NULL);
 791         return;
 792     }
 793
 794     //Remove the DocObj menus first
 795     menuItemCount = GetMenuItemCount(m_hDocObjMenu);
 796     for (int index=0; index < menuItemCount; index++)
 797     {
 798         RemoveMenu(m_hSharedMenu, m_MenuGroupWidth.width[0], MF_BYPOSITION);
 799     }
 800
 801     //Remove the container's menus next
 802     m_pInPlaceFrame->RemoveMenus(m_hSharedMenu);
 803
 804     //Destroy resources since we are not going to reuse the menu handles
 805     DestroyMenuResources();
 806 }
 807
 808 void COleDocumentView::DestroyMenuResources()
 809 {
 810     //Destroy the shared menu handle
 811     if (m_hSharedMenu)
 812     {
 813         DestroyMenu(m_hSharedMenu);
 814         m_hSharedMenu = NULL;
 815     }
 816
 817     //Destroy our local docobj menu handle
 818     if (m_hDocObjMenu)
 819     {
 820         DestroyMenu(m_hDocObjMenu);
 821         m_hDocObjMenu = NULL;
 822         // The 'view' menu is just part of m_hDocObjMenu and
 823         // does not need to be destroyed separately.
 824         m_hViewMenu = NULL;
 825     }
 826
 827     //Destroy the Ole menu descriptor
 828     if (m_hOleMenu)
 829     {
 830         OleDestroyMenuDescriptor(m_hOleMenu);
 831         m_hOleMenu = NULL;
 832     }
 833 }